home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 November: Tool Chest / Dev.CD Nov 94.toast / Tool Chest / QuickDraw GX / QuickDraw GX Info / QuickDraw GX Interfaces / Interfaces & Libraries / graphics libraries / camera library.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-30  |  4.3 KB  |  109 lines  |  [TEXT/MPS ]
  1. /* graphics libraries:
  2.     Perspective gxMapping generation routines
  3.     by Cary Clark, Georgiann Delaney, Michael Fairman, Dave Good, Robert Johnson, Keith McGreggor, Oliver Steele, David Van Brink, Chris Yerga
  4.     Copyright 1987 - 1991 Apple Computer, Inc.  All rights reserved.    */
  5.  
  6. #include "graphics libraries.h"
  7. #include "camera library.h"
  8.  
  9.  
  10. void InitCamera(camera *obscura)
  11. {
  12.     obscura->location.x = 0;
  13.     obscura->location.y = 0;
  14.     obscura->location.z = -IntToFixed(1440);    /* 20 inches backward */
  15.     obscura->axis.x = 0;
  16.     obscura->axis.y = 0;
  17.     obscura->axis.z = fixed1;             /* forward */
  18.     obscura->zenith.x = 0;
  19.     obscura->zenith.y = -fixed1;          /* up */
  20.     obscura->zenith.z = 0;
  21.     obscura->observer.x = 0;
  22.     obscura->observer.y = 0;
  23.     obscura->observer.z = -IntToFixed(1440);    /* 20 inches backward */
  24.     UpdateCamera(obscura);
  25. }
  26.  
  27. void UpdateCamera(camera *obscura)
  28. {
  29.     unit3D temp[2];
  30.     register unit3D *axis = temp;
  31.     register unit3D *zenith = axis + 1;
  32.     Unitize(&obscura->axis, axis);
  33.     {   register Fixed dot = FracDot((unit3D *)&obscura->zenith, axis);
  34.         zenith->x = obscura->zenith.x - FractMultiply(dot, axis->x);
  35.         zenith->y = obscura->zenith.y - FractMultiply(dot, axis->y);
  36.         zenith->z = obscura->zenith.z - FractMultiply(dot, axis->z);
  37.         Unitize((point3D *)zenith, zenith);
  38.     }
  39.     {   register unit3D *destPtr = (unit3D *)&obscura->orientation.map[0][0];
  40.         FracCross(axis, zenith, destPtr++);
  41.         *destPtr++ = *zenith;
  42.         *destPtr++ = *axis;
  43.     }
  44.     {   register Fixed *destPtr = &obscura->orientation.map[0][0];
  45.         register Fixed x = obscura->observer.x;
  46.         register Fixed y = obscura->observer.y;
  47.         register Fixed z = obscura->observer.z;
  48.         destPtr[0] = -FractMultiply(z, destPtr[0]) + FractMultiply(x, destPtr[6]);
  49.         destPtr[1] = -FractMultiply(z, destPtr[1]) + FractMultiply(x, destPtr[7]);
  50.         destPtr[2] = -FractMultiply(z, destPtr[2]) + FractMultiply(x, destPtr[8]);
  51.         destPtr[3] = FractMultiply(z, destPtr[3]) + FractMultiply(y, destPtr[6]);
  52.         destPtr[4] = FractMultiply(z, destPtr[4]) + FractMultiply(y, destPtr[7]);
  53.         destPtr[5] = FractMultiply(z, destPtr[5]) + FractMultiply(y, destPtr[8]);
  54.     }
  55. }
  56.  
  57. void PatchToCameraMap(patch *quilt, camera *obscura, gxMapping *map)
  58. {
  59.     register Fixed *destPtr = &map->map[0][0];
  60.     register Fixed *mapPtr = &obscura->orientation.map[0][0];
  61.     register Fixed *patchPtr;
  62.     point3D diff;
  63.     register Fixed dot;
  64.  
  65.     diff.x = quilt->origin.x - obscura->location.x;
  66.     diff.y = quilt->origin.y - obscura->location.y;
  67.     diff.z = quilt->origin.z - obscura->location.z;
  68.     dot = FracDot((unit3D *)&diff, (unit3D *)&obscura->orientation.map[2][0]);
  69.  
  70.     patchPtr = (Fixed *)quilt;
  71.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr, 1, dot);
  72.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr+3, 1, dot);
  73.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr+6, 1, dot);
  74.     patchPtr += 3;
  75.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr, 1, dot);
  76.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr+3, 1, dot);
  77.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr+6, 1, dot);
  78.     patchPtr = (Fixed *)&diff;
  79.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr, 1, dot);
  80.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr+3, 1, dot);
  81.     *destPtr = fract1;
  82. }
  83.  
  84. Fixed Unitize(point3D *aPoint, unit3D *bPoint)
  85. {
  86.     register Fixed r = Magnitude(Magnitude(aPoint->x, aPoint->y), aPoint->z);
  87.     if (bPoint)
  88.     {   bPoint->x = FractDivide(aPoint->x, r);
  89.         bPoint->y = FractDivide(aPoint->y, r);
  90.         bPoint->z = FractDivide(aPoint->z, r);
  91.     }
  92.     return r;
  93. }
  94.  
  95. fract FracDot(unit3D *aPoint, unit3D *bPoint)
  96. {
  97.     return FractMultiply(aPoint->x, bPoint->x) + FractMultiply(aPoint->y, bPoint->y) + FractMultiply(aPoint->z, bPoint->z);
  98. }
  99.  
  100. void FracCross(unit3D *aPoint, unit3D *bPoint, unit3D *cPoint)
  101. {
  102.     unit3D temp;
  103.     register fract *tempPtr = (fract *)&temp;
  104.     *tempPtr++ = FractMultiply(aPoint->y, bPoint->z) - FractMultiply(aPoint->z, bPoint->y);
  105.     *tempPtr++ = FractMultiply(aPoint->z, bPoint->x) - FractMultiply(aPoint->x, bPoint->z);
  106.     *tempPtr++ = FractMultiply(aPoint->x, bPoint->y) - FractMultiply(aPoint->y, bPoint->x);
  107.     *cPoint = temp;
  108. }
  109.